home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / python2.4 / socket.py < prev    next >
Encoding:
Python Source  |  2007-04-12  |  12.3 KB  |  401 lines
  1. # Wrapper module for _socket, providing some additional facilities
  2. # implemented in Python.
  3.  
  4. """\
  5. This module provides socket operations and some related functions.
  6. On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
  7. On other systems, it only supports IP. Functions specific for a
  8. socket are available as methods of the socket object.
  9.  
  10. Functions:
  11.  
  12. socket() -- create a new socket object
  13. socketpair() -- create a pair of new socket objects [*]
  14. fromfd() -- create a socket object from an open file descriptor [*]
  15. gethostname() -- return the current hostname
  16. gethostbyname() -- map a hostname to its IP number
  17. gethostbyaddr() -- map an IP number or hostname to DNS info
  18. getservbyname() -- map a service name and a protocol name to a port number
  19. getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
  20. ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  21. htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  22. inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  23. inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  24. ssl() -- secure socket layer support (only available if configured)
  25. socket.getdefaulttimeout() -- get the default timeout value
  26. socket.setdefaulttimeout() -- set the default timeout value
  27.  
  28.  [*] not available on all platforms!
  29.  
  30. Special objects:
  31.  
  32. SocketType -- type object for socket objects
  33. error -- exception raised for I/O errors
  34. has_ipv6 -- boolean value indicating if IPv6 is supported
  35.  
  36. Integer constants:
  37.  
  38. AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  39. SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  40.  
  41. Many other constants may be defined; these may be used in calls to
  42. the setsockopt() and getsockopt() methods.
  43. """
  44.  
  45. import _socket
  46. from _socket import *
  47.  
  48. _have_ssl = False
  49. try:
  50.     import _ssl
  51.     from _ssl import *
  52.     _have_ssl = True
  53. except ImportError:
  54.     pass
  55.  
  56. import os, sys
  57.  
  58. try:
  59.     from errno import EBADF
  60. except ImportError:
  61.     EBADF = 9
  62.  
  63. __all__ = ["getfqdn"]
  64. __all__.extend(os._get_exports_list(_socket))
  65. if _have_ssl:
  66.     __all__.extend(os._get_exports_list(_ssl))
  67.  
  68. _realsocket = socket
  69. if _have_ssl:
  70.     _realssl = ssl
  71.     def ssl(sock, keyfile=None, certfile=None):
  72.         if hasattr(sock, "_sock"):
  73.             sock = sock._sock
  74.         return _realssl(sock, keyfile, certfile)
  75.  
  76. # WSA error codes
  77. if sys.platform.lower().startswith("win"):
  78.     errorTab = {}
  79.     errorTab[10004] = "The operation was interrupted."
  80.     errorTab[10009] = "A bad file handle was passed."
  81.     errorTab[10013] = "Permission denied."
  82.     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
  83.     errorTab[10022] = "An invalid operation was attempted."
  84.     errorTab[10035] = "The socket operation would block"
  85.     errorTab[10036] = "A blocking operation is already in progress."
  86.     errorTab[10048] = "The network address is in use."
  87.     errorTab[10054] = "The connection has been reset."
  88.     errorTab[10058] = "The network has been shut down."
  89.     errorTab[10060] = "The operation timed out."
  90.     errorTab[10061] = "Connection refused."
  91.     errorTab[10063] = "The name is too long."
  92.     errorTab[10064] = "The host is down."
  93.     errorTab[10065] = "The host is unreachable."
  94.     __all__.append("errorTab")
  95.  
  96.  
  97.  
  98. def getfqdn(name=''):
  99.     """Get fully qualified domain name from name.
  100.  
  101.     An empty argument is interpreted as meaning the local host.
  102.  
  103.     First the hostname returned by gethostbyaddr() is checked, then
  104.     possibly existing aliases. In case no FQDN is available, hostname
  105.     as returned by gethostname() is returned.
  106.     """
  107.     name = name.strip()
  108.     if not name or name == '0.0.0.0':
  109.         name = gethostname()
  110.     try:
  111.         hostname, aliases, ipaddrs = gethostbyaddr(name)
  112.     except error:
  113.         pass
  114.     else:
  115.         aliases.insert(0, hostname)
  116.         for name in aliases:
  117.             if '.' in name:
  118.                 break
  119.         else:
  120.             name = hostname
  121.     return name
  122.  
  123.  
  124. _socketmethods = (
  125.     'bind', 'connect', 'connect_ex', 'fileno', 'listen',
  126.     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
  127.     'sendall', 'setblocking',
  128.     'settimeout', 'gettimeout', 'shutdown')
  129.  
  130. if sys.platform == "riscos":
  131.     _socketmethods = _socketmethods + ('sleeptaskw',)
  132.  
  133. class _closedsocket(object):
  134.     __slots__ = []
  135.     def _dummy(*args):
  136.         raise error(EBADF, 'Bad file descriptor')
  137.     send = recv = sendto = recvfrom = __getattr__ = _dummy
  138.  
  139. class _socketobject(object):
  140.  
  141.     __doc__ = _realsocket.__doc__
  142.  
  143.     __slots__ = ["_sock", "send", "recv", "sendto", "recvfrom",
  144.                  "__weakref__"]
  145.  
  146.     def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
  147.         if _sock is None:
  148.             _sock = _realsocket(family, type, proto)
  149.         self._sock = _sock
  150.         self.send = self._sock.send
  151.         self.recv = self._sock.recv
  152.         self.sendto = self._sock.sendto
  153.         self.recvfrom = self._sock.recvfrom
  154.  
  155.     def close(self):
  156.         self._sock = _closedsocket()
  157.         self.send = self.recv = self.sendto = self.recvfrom = self._sock._dummy
  158.     close.__doc__ = _realsocket.close.__doc__
  159.  
  160.     def accept(self):
  161.         sock, addr = self._sock.accept()
  162.         return _socketobject(_sock=sock), addr
  163.     accept.__doc__ = _realsocket.accept.__doc__
  164.  
  165.     def dup(self):
  166.         """dup() -> socket object
  167.  
  168.         Return a new socket object connected to the same system resource."""
  169.         return _socketobject(_sock=self._sock)
  170.  
  171.     def makefile(self, mode='r', bufsize=-1):
  172.         """makefile([mode[, bufsize]]) -> file object
  173.  
  174.         Return a regular file object corresponding to the socket.  The mode
  175.         and bufsize arguments are as for the built-in open() function."""
  176.         return _fileobject(self._sock, mode, bufsize)
  177.  
  178.     _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
  179.           "%s.__doc__ = _realsocket.%s.__doc__\n")
  180.     for _m in _socketmethods:
  181.         exec _s % (_m, _m, _m, _m)
  182.     del _m, _s
  183.  
  184. socket = SocketType = _socketobject
  185.  
  186. class _fileobject(object):
  187.     """Faux file object attached to a socket object."""
  188.  
  189.     default_bufsize = 8192
  190.     name = "<socket>"
  191.  
  192.     __slots__ = ["mode", "bufsize", "softspace",
  193.                  # "closed" is a property, see below
  194.                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf"]
  195.  
  196.     def __init__(self, sock, mode='rb', bufsize=-1):
  197.         self._sock = sock
  198.         self.mode = mode # Not actually used in this version
  199.         if bufsize < 0:
  200.             bufsize = self.default_bufsize
  201.         self.bufsize = bufsize
  202.         self.softspace = False
  203.         if bufsize == 0:
  204.             self._rbufsize = 1
  205.         elif bufsize == 1:
  206.             self._rbufsize = self.default_bufsize
  207.         else:
  208.             self._rbufsize = bufsize
  209.         self._wbufsize = bufsize
  210.         self._rbuf = "" # A string
  211.         self._wbuf = [] # A list of strings
  212.  
  213.     def _getclosed(self):
  214.         return self._sock is None
  215.     closed = property(_getclosed, doc="True if the file is closed")
  216.  
  217.     def close(self):
  218.         try:
  219.             if self._sock:
  220.                 self.flush()
  221.         finally:
  222.             self._sock = None
  223.  
  224.     def __del__(self):
  225.         try:
  226.             self.close()
  227.         except:
  228.             # close() may fail if __init__ didn't complete
  229.             pass
  230.  
  231.     def flush(self):
  232.         if self._wbuf:
  233.             buffer = "".join(self._wbuf)
  234.             self._wbuf = []
  235.             self._sock.sendall(buffer)
  236.  
  237.     def fileno(self):
  238.         return self._sock.fileno()
  239.  
  240.     def write(self, data):
  241.         data = str(data) # XXX Should really reject non-string non-buffers
  242.         if not data:
  243.             return
  244.         self._wbuf.append(data)
  245.         if (self._wbufsize == 0 or
  246.             self._wbufsize == 1 and '\n' in data or
  247.             self._get_wbuf_len() >= self._wbufsize):
  248.             self.flush()
  249.  
  250.     def writelines(self, list):
  251.         # XXX We could do better here for very long lists
  252.         # XXX Should really reject non-string non-buffers
  253.         self._wbuf.extend(filter(None, map(str, list)))
  254.         if (self._wbufsize <= 1 or
  255.             self._get_wbuf_len() >= self._wbufsize):
  256.             self.flush()
  257.  
  258.     def _get_wbuf_len(self):
  259.         buf_len = 0
  260.         for x in self._wbuf:
  261.             buf_len += len(x)
  262.         return buf_len
  263.  
  264.     def read(self, size=-1):
  265.         data = self._rbuf
  266.         if size < 0:
  267.             # Read until EOF
  268.             buffers = []
  269.             if data:
  270.                 buffers.append(data)
  271.             self._rbuf = ""
  272.             if self._rbufsize <= 1:
  273.                 recv_size = self.default_bufsize
  274.             else:
  275.                 recv_size = self._rbufsize
  276.             while True:
  277.                 data = self._sock.recv(recv_size)
  278.                 if not data:
  279.                     break
  280.                 buffers.append(data)
  281.             return "".join(buffers)
  282.         else:
  283.             # Read until size bytes or EOF seen, whichever comes first
  284.             buf_len = len(data)
  285.             if buf_len >= size:
  286.                 self._rbuf = data[size:]
  287.                 return data[:size]
  288.             buffers = []
  289.             if data:
  290.                 buffers.append(data)
  291.             self._rbuf = ""
  292.             while True:
  293.                 left = size - buf_len
  294.                 recv_size = max(self._rbufsize, left)
  295.                 data = self._sock.recv(recv_size)
  296.                 if not data:
  297.                     break
  298.                 buffers.append(data)
  299.                 n = len(data)
  300.                 if n >= left:
  301.                     self._rbuf = data[left:]
  302.                     buffers[-1] = data[:left]
  303.                     break
  304.                 buf_len += n
  305.             return "".join(buffers)
  306.  
  307.     def readline(self, size=-1):
  308.         data = self._rbuf
  309.         if size < 0:
  310.             # Read until \n or EOF, whichever comes first
  311.             if self._rbufsize <= 1:
  312.                 # Speed up unbuffered case
  313.                 assert data == ""
  314.                 buffers = []
  315.                 recv = self._sock.recv
  316.                 while data != "\n":
  317.                     data = recv(1)
  318.                     if not data:
  319.                         break
  320.                     buffers.append(data)
  321.                 return "".join(buffers)
  322.             nl = data.find('\n')
  323.             if nl >= 0:
  324.                 nl += 1
  325.                 self._rbuf = data[nl:]
  326.                 return data[:nl]
  327.             buffers = []
  328.             if data:
  329.                 buffers.append(data)
  330.             self._rbuf = ""
  331.             while True:
  332.                 data = self._sock.recv(self._rbufsize)
  333.                 if not data:
  334.                     break
  335.                 buffers.append(data)
  336.                 nl = data.find('\n')
  337.                 if nl >= 0:
  338.                     nl += 1
  339.                     self._rbuf = data[nl:]
  340.                     buffers[-1] = data[:nl]
  341.                     break
  342.             return "".join(buffers)
  343.         else:
  344.             # Read until size bytes or \n or EOF seen, whichever comes first
  345.             nl = data.find('\n', 0, size)
  346.             if nl >= 0:
  347.                 nl += 1
  348.                 self._rbuf = data[nl:]
  349.                 return data[:nl]
  350.             buf_len = len(data)
  351.             if buf_len >= size:
  352.                 self._rbuf = data[size:]
  353.                 return data[:size]
  354.             buffers = []
  355.             if data:
  356.                 buffers.append(data)
  357.             self._rbuf = ""
  358.             while True:
  359.                 data = self._sock.recv(self._rbufsize)
  360.                 if not data:
  361.                     break
  362.                 buffers.append(data)
  363.                 left = size - buf_len
  364.                 nl = data.find('\n', 0, left)
  365.                 if nl >= 0:
  366.                     nl += 1
  367.                     self._rbuf = data[nl:]
  368.                     buffers[-1] = data[:nl]
  369.                     break
  370.                 n = len(data)
  371.                 if n >= left:
  372.                     self._rbuf = data[left:]
  373.                     buffers[-1] = data[:left]
  374.                     break
  375.                 buf_len += n
  376.             return "".join(buffers)
  377.  
  378.     def readlines(self, sizehint=0):
  379.         total = 0
  380.         list = []
  381.         while True:
  382.             line = self.readline()
  383.             if not line:
  384.                 break
  385.             list.append(line)
  386.             total += len(line)
  387.             if sizehint and total >= sizehint:
  388.                 break
  389.         return list
  390.  
  391.     # Iterator protocols
  392.  
  393.     def __iter__(self):
  394.         return self
  395.  
  396.     def next(self):
  397.         line = self.readline()
  398.         if not line:
  399.             raise StopIteration
  400.         return line
  401.